<!DOCTYPE html>
<html lang="zh-CN">

<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <link rel="stylesheet" href="./css/style.css">
  <title>判断</title>
  </title>
</head>

<body>

  <p>36 + 1 = ?</p>
  <input type="number" id="in">
  <button id="btn">提交</button>

  <ul>
    <li></li>
    <li></li>
    <li></li>
    <li></li>
    <li></li>
    <li></li>
    <li></li>
    <li></li>
    <li></li>
    <li></li>
  </ul>
  <script src="./js/idnex.js"></script>
  <!-- 
        条件判断和循环：
            根据变量不同的状态，有选择的执行不同的代码；
            
        1.判断：
            判断相等：
                A === B 返回true 表示A、B完全相等； === 是js里特殊的全等符号；

                根据不同的状态 执行不同的代码：

            其实这个判断语句，就这么几个单词：
            
            if、else、switc、case、break

            怎么玩？

            (1) 独立事件：你玩你的 我玩我的 咱俩互不干扰...
                
                if(你在家吗？){
                    在的话，我就去你家玩...
                }

                if(那只小狗可爱吗？){
                    可爱的话，我们就把它偷走吧...
                }

                你在不在家 跟 狗可不可爱 不会相互影响，所以两种情况都会去判断...

            (2) 同一对象的互斥事件：你玩我就不玩了 你不玩那我玩...
                
                if(你上王者了吗？){
                    上了，那我给你一百块...
                }else{
                    没上，那你给我一百块...
                }
                
                你上没上王者，只有两种状态，上了 或者没上 所以只会执行其中一种...

            (3) 同一对象的多种互斥事件： 你是男人 还是非男人...
                
                if(你是男人吗？){
                    是，你就去男厕所...
                }else if(你是女人吗？){
                    是，你就去女厕所...
                }else if(你是第三种性别吗？){
                    是，那就去某泰姓国家找找厕所吧...
                }else {
                    非男非女非第三种的所有其他情况...去找个小树林吧就...
                }
                
                同一目标可能存在多种情况...就嵌套吧...

            switch...case语句：
                switch(传入一个值或是能得到一个值的表达式){
                    case 值1:
                        业务1
                        break
                    case 值2:
                        业务2
                        break
                    case 3:
                    case 4:
                        业务3
                        break
                    default:
                        默认业务(可选)
                        break
                }
            这就类似于一个开关，相比起if else语句...
                就像是 离散 跟 连续 的区别...
                
                if语句更适用于某个范围内连续的值的判断，
                switch语句更适用于 一系列 明确的值的判断；

                因此 switch 语句不是很常用，离散性，是它的一个缺陷...

                注意break就行，如果不使用break，这个判断后续的代码还是会运行；

            注意if else语句的嵌套：
                if(A){
                    if(B){
                        if(c){
                            ...
                        }else if{
                            ...
                        }eles{
                            ...
                        }
                    }else{
                        ...
                    }
                }eles{
                    ...
                }

            emmm...诸如此类 需要条件嵌套的情况，一定要把逻辑、所有情形搞清楚....
            慎用这种嵌套，好好写注释，能用函数简化功能的就尽量不要这么嵌套...

            条件判断的优化小技巧：
                判断尽量写在函数里，然后就可以 少用else语句

                func foo(a){
                    if(a>0){
                        return 1 
                    }
                    
                    因为return语句表示结束函数，就不会再去执行后续语句了 就不必else了

                    return 0
                }

                如果只是单纯判断一个目标存不存在 或者 对与错
                直接写：
                    if(boolean){
                        return bloolean
                    } 

            本节作业1：
                实现一个函数，判断一个三位数是否为水仙花数：
                要求：
                    1.接收用户的输入，然后点击提交按钮，弹出判断结果；
                    2.只能使用当前所学的知识，不能超纲；
                提示：
                    水仙花数：
                        三位数 每个位的数字的立方之和 等于该三位数本身；

                        例如： 153 = 1^3 + 5^3 +3^3

                    用户输入框里输入的是字符串，如果需要转化为数字：
                        '123' * 1 = 123 (隐式类型转换)   
                    数字转化为字符串：
                        123 + '' = '123'

        2.循环：
           用于做大量重复的操作，就不必重复写很多遍相同的代码了;
           
           其实循环就两种：

           (1) 确定循环次数的语法：
                for(初始条件;结束条件;控制表达式){
                    要循环的代码；
                }

                for(let i = 0 ; i < 10 ; i++){
                    console.log(i)
                }

                之所以从0开始，是因为可以跟数组一一对应

                写循环代码，永远抓住 用来控制循环的 变量！

                自增自减：
                    let i = 1
                    log(i) // 1 原值 

                    经过下列操作之后：

                    i++：先运算 再加1  log(i) 1
                    i--：先运算 再减1  log(i) 1
                    ++i: 先加1 再运算  log(i) 2
                    --i: 先减1 再运算  log(i) 0

                    是不是有点晕...到底怎么理解？

                    其实从返回值的角度来看，就很明了了：
                    不管哪种写法，都是一个表达式，则必然有一个返回值，

                    那么：
                        运算符在后面的写法，就是先返回原来的值 再去运算；
                        它返回的永远是运算之前的值；

                        运算符在前面的写法，就是先运算，再返回运算后的值；
                        它返回的永远是运算之后的值；

                从0开始，确定打印十次，只要不满十次，就自增 1；

                for(;;){
                    这是无条件进入循环，也是个死循环；
                }

                for循环的执行顺序：(标准写法)
                    for(A;B;C){
                        D...
                    }

                    A => (B => D => C) => ... => B;

                    相当于：(不建议这么写)

                    A
                    for(;B;){
                        D;
                        C;
                    }

                for循环中 最重要的是 结束条件 B;
                
                循环嵌套：
                    for(){
                        for(){
                            for(){}
                        }
                    }
                这个东西，没啥好说的，就是外层每执行一次，内层就要全部执行一遍；

           (2) 不确定循环次数的语法：
                直到型：
                do{
                    先进入循环；
                    然后控制重复状态；
                }whlie(true)

                先循环 再判断

                当型：
                while(true){

                    不满足就进来循环；
                    然后再控制重复状态；
                }
                
                先判断 再循环；

        3.中断：
            中断就是让循环达到中断条件之后，跳过某一次循环 或者 全部跳过；
            就两个单词：
                break:
                    跳出当前整个循环；

                    for(){
                        if(...){
                            break
                        }
                    }

                continue:
                    跳过当前这一步，继续循环后面的代码；
                    for(){
                        if(...){
                            continue
                        }
                    }

            break用的多一点，continue很少用；
            通常这俩都需要结合判断条件来进行！

            如果想要中断指定的循环，可以在循环前面加个名字:
            forA: for(){
                forB: for(){
                    if(...){
                        break forA 几乎用不到这种方式
                    }
                }
            }

        本节作业2：
            找到 100 ~ 999 所有水仙花数；
        本节作业3：
            在页面输出一个9*9乘法表；
     -->

</body>

</html>